JavaScriptのパターンマッチング網羅性：完全なパターンカバレッジの確保

            
function describeStatusCode(statusCode) {
  switch (statusCode) {
    case 200:
      return "OK";
    case 404:
      return "Not Found";
    case 500:
      return "Internal Server Error";
    default:
      return "Unknown Status Code";
  }
}

            

              
                Copy
              
            
          

            
function processOrder(order) {
  if (order && order.type === 'shipping' && order.address) {
    // Handle shipping order
    console.log(`Shipping order to: ${order.address}`);
  } else if (order && order.type === 'pickup' && order.location) {
    // Handle pickup order
    console.log(`Pickup order at: ${order.location}`);
  } else {
    // Handle invalid or unsupported order type
    console.error('Invalid order type');
  }
}

// Example usage:
processOrder({ type: 'shipping', address: '123 Main St' });
processOrder({ type: 'pickup', location: 'Downtown Store' });
processOrder({ type: 'delivery', address: '456 Elm St' }); // This will go to the 'else' block

            

              
                Copy
              
            
          

            
// Hypothetical example using a pattern matching library

// Assuming a library named 'pattern-match' exists
// import match from 'pattern-match';

// Simulate a match function (replace with actual library function)
const match = (value, patterns) => {
  for (const [pattern, action] of patterns) {
    if (typeof pattern === 'function' && pattern(value)) {
      return action(value);
    } else if (value === pattern) {
      return action(value);
    }
  }
  throw new Error('Non-exhaustive pattern match!');
};

function processEvent(event) {
  const result = match(event, [
    [ { type: 'click', target: 'button' }, (e) => `Button Clicked: ${e.target}` ],
    [ { type: 'keydown', key: 'Enter' }, (e) => 'Enter Key Pressed' ],
    [ (e) => true, (e) => { throw new Error("Unhandled event type"); } ] // Default case to ensure exhaustiveness
  ]);

  return result;
}

console.log(processEvent({ type: 'click', target: 'button' }));
console.log(processEvent({ type: 'keydown', key: 'Enter' }));

try {
    console.log(processEvent({ type: 'mouseover', target: 'div' }));
} catch (error) {
    console.error(error.message); // Handles the unhandled event type
}

            

              
                Copy
              
            
          

            
// Discriminated Union for Payment Methods
const PaymentMethods = {
  CreditCard: (cardNumber, expiryDate, cvv) => ({
    type: 'creditCard',
    cardNumber,
    expiryDate,
    cvv,
  }),
  PayPal: (email) => ({
    type: 'paypal',
    email,
  }),
  BankTransfer: (accountNumber, sortCode) => ({
    type: 'bankTransfer',
    accountNumber,
    sortCode,
  }),
};

function processPayment(payment) {
  switch (payment.type) {
    case 'creditCard':
      console.log(`Processing credit card payment: ${payment.cardNumber}`);
      break;
    case 'paypal':
      console.log(`Processing PayPal payment: ${payment.email}`);
      break;
    case 'bankTransfer':
      console.log(`Processing bank transfer: ${payment.accountNumber}`);
      break;
    default:
      throw new Error(`Unsupported payment method: ${payment.type}`); // Exhaustiveness check
  }
}

const creditCardPayment = PaymentMethods.CreditCard('1234-5678-9012-3456', '12/24', '123');
const paypalPayment = PaymentMethods.PayPal('user@example.com');

processPayment(creditCardPayment);
processPayment(paypalPayment);

// Simulate an unsupported payment method (e.g., Cryptocurrency)
try {
  processPayment({ type: 'cryptocurrency', address: '0x...' });
} catch (error) {
  console.error(error.message);
}

            

              
                Copy
              
            
          

            
// TypeScript Example with Exhaustiveness Checking

type PaymentMethod =
  | { type: 'creditCard'; cardNumber: string; expiryDate: string; cvv: string }
  | { type: 'paypal'; email: string }
  | { type: 'bankTransfer'; accountNumber: string; sortCode: string };

function processPayment(payment: PaymentMethod): string {
  switch (payment.type) {
    case 'creditCard':
      return `Processing credit card payment: ${payment.cardNumber}`;
    case 'paypal':
      return `Processing PayPal payment: ${payment.email}`;
    case 'bankTransfer':
      return `Processing bank transfer: ${payment.accountNumber}`;
    default:
      // This will cause a compile-time error if not all cases are handled
      const _exhaustiveCheck: never = payment;
      return _exhaustiveCheck; // Required to satisfy the return type
  }
}

const creditCardPayment: PaymentMethod = { type: 'creditCard', cardNumber: '1234-5678-9012-3456', expiryDate: '12/24', cvv: '123' };
const paypalPayment: PaymentMethod = { type: 'paypal', email: 'user@example.com' };

console.log(processPayment(creditCardPayment));
console.log(processPayment(paypalPayment));

// The following line would cause a compile-time error:
// console.log(processPayment({ type: 'cryptocurrency', address: '0x...' }));


            

              
                Copy
              
            
          

            
// Naive (and incorrect) address processing
function processAddress(address) {
  // Assumes US address format: Street, City, State, Zip
  const parts = address.split(',');
  if (parts.length !== 4) {
    console.error('Invalid address format');
    return;
  }
  const street = parts[0].trim();
  const city = parts[1].trim();
  const state = parts[2].trim();
  const zip = parts[3].trim();

  console.log(`Street: ${street}, City: ${city}, State: ${state}, Zip: ${zip}`);
}

processAddress('123 Main St, Anytown, CA, 91234'); // Works
processAddress('Some Street 123, Berlin, 10115, Germany'); // Fails - wrong format

            

              
                Copy